package base.java8;

import java.util.function.*;

/**
 * 1. 生产类(不接受参数,返回结果)
 * <p>
 * * {@link Supplier}           生产一个T
 * * {@link IntSupplier}        生产一个Int
 * * {@link LongSupplier}       生产一个Long
 * * {@link DoubleSupplier}     生产一个Double
 * * {@link BooleanSupplier}    生产一个Boolean
 * </p>
 * 2. 消费类(接受参数,不返回)
 * <p>
 * * {@link Consumer}           消费一个T
 * * {@link IntConsumer}        消费一个Int
 * * {@link LongConsumer }      消费一个Long
 * * {@link DoubleConsumer}     消费一个Double
 * * {@link BiConsumer}         消费两个T
 * * {@link ObjIntConsumer}     消费一个T,一个Int
 * * {@link ObjLongConsumer}    消费一个T,一个Long
 * * {@link ObjDoubleConsumer}  消费一个T,一个Double
 * </p>
 * 3. 断言类(接受参数,返回Boolean)
 * <p>
 * * {@link Predicate}          断言一个T,返回Boolean
 * * {@link IntPredicate}       断言一个Int,返回Boolean
 * * {@link LongPredicate}      断言一个Long,返回Boolean
 * * {@link DoublePredicate}    断言一个Double,返回Boolean
 * * {@link BiPredicate}        断言[T,U],返回Boolean
 * </p>
 * 4. 转换类(接受参数,返回参数)
 * <p>
 * *  一转一
 * * * {@link Function}                接受一个T,返回一个R
 * * * {@link IntFunction}             接受一个Int,返回一个R
 * * * {@link LongFunction}            接受一个Long,返回一个R
 * * * {@link DoubleFunction}          接受一个Double,返回一个R
 * * * {@link IntUnaryOperator}        接受一个Int,返回一个Int
 * * * {@link IntToLongFunction}       接受一个Int,返回一个Long
 * * * {@link IntToDoubleFunction}     接受一个Int,返回一个Double
 * * * {@link LongUnaryOperator}       接受一个Long,返回一个Long
 * * * {@link LongToIntFunction}       接受一个Long,返回一个Int
 * * * {@link LongToDoubleFunction}    接受一个Long,返回一个Double
 * * * {@link DoubleUnaryOperator}     接受一个Double,返回一个Double
 * * * {@link DoubleToIntFunction}     接受一个Double,返回一个Int
 * * * {@link DoubleToLongFunction}    接受一个Double,返回一个Long
 * * * {@link UnaryOperator}           接受一个T,返回一个T
 * * * {@link ToIntFunction}           接受一个T,返回一个Int
 * * * {@link ToLongBiFunction}        接受一个T,返回一个Long
 * * * {@link ToDoubleFunction}        接受一个T,返回一个Double
 * <p>
 * *  二转一
 * * * {@link BiFunction}              接受[T,U],返回一个R
 * * * {@link BinaryOperator}          接受两个T,返回一个T
 * * * {@link ToIntBiFunction}         接受[T,U],返回一个Int
 * * * {@link ToLongBiFunction}        接受[T,U],返回一个Long
 * * * {@link ToDoubleBiFunction}      接受[T,U],返回一个Double
 * * * {@link IntBinaryOperator}       接受两个Int,返回一个Int
 * * * {@link LongBinaryOperator}      接受两个Long,返回一个Long
 * * * {@link DoubleBinaryOperator}    接受两个Double,返回一个Double
 * </p>
 *
 * @author 王霄
 * @date 2021/9/11 13:13
 */
public class FunctionDemo {
    public static void main(String[] args) {
        IntUnaryOperator operator = x -> x * x;
        IntUnaryOperator operator2 = x -> x + x;
        //andThen由左向右执行
        System.out.println(operator.andThen(operator2).applyAsInt(5));
        //compose由左向右执行
        System.out.println(operator.compose(operator2).applyAsInt(5));
    }
}
